home *** CD-ROM | disk | FTP | other *** search
/ TPUG - Toronto PET Users Group / TPUG Users Group CD / TPUG Users Group CD.iso / AMIGA / AMICUS / AMICUS01.ADF / C / objfix.c < prev    next >
C/C++ Source or Header  |  1985-11-15  |  12KB  |  341 lines
  1.  
  2. /* objfix.c */
  3.  
  4. /****************************************************************/
  5. /* Fixup routine for object files output from Lattice C         */
  6. /* makes external symbols available to Wack!                    */
  7. /*                                                              */
  8. /* part of the Amiga Programmer's Library                       */
  9. /* Note, originally compiled with microsoft C 3.0 for the PC    */
  10. /*                                                              */
  11. /*      Copyright (c) 1985 by Michael G. Lehman, MaxiCorp       */
  12. /*      All rights reserved, posted on bulletin boards by       */
  13. /*      permission.                                             */
  14. /****************************************************************/
  15.  
  16. /* define the right symbols for your C compiler and environment */
  17.  
  18. #define LATTI
  19. #undef MSC30
  20.  
  21.  
  22. #include <stdio.h>
  23. #include <fcntl.h>
  24.  
  25. /* these are needed for Microsoft C v3.0 */
  26. #ifdef MSC30
  27. #include <sys\types.h>  /*included so sys\stat.h works */
  28. #include <sys\stat.h>   /* included to get S_IREAD && S_IWRITE */
  29. #define O_RAW O_BINARY
  30. #endif
  31.  
  32. struct {
  33.      unsigned long len;         /* symbol table field length */
  34.      unsigned long sym[40];     /* 160 chars max */
  35.      unsigned long value;
  36. } symhunk[100];                 /* allow for 100 symbols */
  37.  
  38. int nxtsym;
  39. int width;
  40. long startoffset;
  41. int f;
  42.  
  43. main(argc,argv)
  44. int argc;
  45. char **argv;
  46. {
  47.   int infile;
  48.   long l;
  49.   unsigned long i,j;
  50.   int open();
  51.   char *fname;
  52.   unsigned long lbuf;
  53.   int debug;
  54.   unsigned char typ;
  55.  
  56.   if (argc < 2)
  57.     {
  58.         printf("Usage: objfix <cnvfile>\n");
  59.         exit(0);
  60.     }
  61.  
  62.   debug = (argc > 2);
  63.  
  64.   fname = argv[1];
  65.  
  66.   if (!*fname)
  67.     return(0);
  68.  
  69.   infile = open(fname,0);
  70.  
  71.   if (infile == -1)
  72.     {
  73.       printf("\n\nUnable to open \"%s\" for dumping\n",fname);
  74.       exit(10);
  75.     }
  76.  
  77. #ifdef MSC30
  78.   f = creat("cnv.tmp",S_IREAD | S_IWRITE);       /* assume binary mode */
  79. #endif
  80. #ifdef LATTI
  81.   f = creat("cnv.tmp", O_RAW | O_RDWR );       /* assume binary mode */
  82. #endif
  83.  
  84.   printf("\nConverting file: \"%s\" \n\n",fname);
  85.  
  86.   nxtsym = 0;
  87.  
  88.   while(1)
  89.     {
  90.       l = read(infile,&lbuf,4);
  91.       if (l!=4)
  92.         break;
  93.       if (lbuf != 0xF2030000)
  94.         putit(lbuf);
  95.       normalize(&lbuf);
  96.       if (debug)
  97.         printf("Block type: 0x%x\n",lbuf);
  98.  
  99.       switch(lbuf)
  100.         {
  101.                 case 0x3E7:     /* hunk_unit */
  102.                 case 0x3E8:     /* hunk_name */
  103.                 case 0x3E9:     /* hunk_code */
  104.                 case 0x3EA:     /* hunk_data */
  105.                                 read(infile,&lbuf,4);
  106.                                 putit(lbuf);
  107.                                 normalize(&lbuf);
  108.                                 for(i=0; i < lbuf; i++)
  109.                                   {
  110.                                     read(infile,&j,4);
  111.                                     putit(j);
  112.                                   }
  113.                                 break;
  114.  
  115.                 case 0x3EB:     /* hunk_bss */
  116.                                 read(infile,&lbuf,4);
  117.                                 putit(lbuf);
  118.                                 break;
  119.  
  120.                 case 0x3EC:     /* hunk_r32 */
  121.                 case 0x3ED:     /* hunk_r16 */
  122.                 case 0x3EE:     /* hunk_r8  */
  123.                                 read(infile,&lbuf,4);
  124.                                 putit(lbuf);
  125.                                 read(infile,&j,4);      /* hunk_number */
  126.                                 putit(j);
  127.                                 normalize(&lbuf);
  128.                                 while(lbuf)
  129.                                   {
  130.                                     for(i=0; i < lbuf; i++)
  131.                                       {
  132.                                         read(infile,&j,4);
  133.                                         putit(j);
  134.                                       }
  135.                                     read(infile,&lbuf,4);
  136.                                     putit(lbuf);
  137.                                     normalize(&lbuf);
  138.                                     if (lbuf)
  139.                                       {
  140.                                         read(infile,&j,4);      /* hunk_number again */
  141.                                         putit(j);
  142.                                       }
  143.                                   }
  144.                                 break;
  145.  
  146.                 case 0x3EF:     /* hunk_ext */
  147.                                 read(infile,&lbuf,4);
  148.                                 putit(lbuf);
  149.                                 j = lbuf;
  150.                                 normalize(&lbuf);
  151.                                 while (lbuf)
  152.                                   {
  153.                                     typ = (lbuf >> 24) & 0xFF;
  154.                                     lbuf &= 0xFFFFFF;
  155.                                     if (debug)
  156.                                       printf("  hunk_ext, typ=%d, len=%d\n",typ,lbuf);
  157.                                     switch(typ)
  158.                                       {
  159.                                         case 1: /* ext_def */
  160.                                                 symhunk[nxtsym].len = j & 0xFFFFFF00;
  161.                                                 for(i=0; i < lbuf; i++)
  162.                                                   {
  163.                                                     read(infile,&j,4);
  164.                                                     putit(j);
  165.                                                     symhunk[nxtsym].sym[i] = j;
  166.                                                   }
  167.                                                 read(infile,&j,4); /* value */
  168.                                                 putit(j);
  169.                                                 symhunk[nxtsym].value = j;
  170.                                                 nxtsym++;
  171.                                                 break;
  172.  
  173.                                         case 2: /* ext_abs */
  174.                                         case 3: /* ext_res */
  175.                                                 for(i=0; i < lbuf; i++)
  176.                                                   {
  177.                                                     read(infile,&j,4);
  178.                                                     putit(j);
  179.                                                   }
  180.                                                 read(infile,&j,4); /* value */
  181.                                                 putit(j);
  182.                                                 break;
  183.                                         case 129: /* ext_ref32 */
  184.                                         case 131: /* ext_ref16 */
  185.                                         case 132: /* ext_ref8  */
  186.                                                 for(i=0; i < lbuf; i++)
  187.                                                   {
  188.                                                     read(infile,&j,4);
  189.                                                     putit(j);
  190.                                                   }
  191.                                                 read(infile,&lbuf,4); /* value */
  192.                                                 putit(lbuf);
  193.                                                 normalize(&lbuf);
  194.                                                 for(i=0; i < lbuf; i++)
  195.                                                   {
  196.                                                     read(infile,&j,4);
  197.                                                     putit(j);
  198.                                                   }
  199.                                                 break;
  200.                                         case 130: /* ext_common */               
  201.                                                 for(i=0; i < lbuf; i++)
  202.                                                   {
  203.                                                     read(infile,&j,4);
  204.                                                     putit(j);
  205.                                                   }
  206.                                                 read(infile,&j,4); /* size */
  207.                                                 putit(j);
  208.                                                 read(infile,&lbuf,4);
  209.                                                 putit(lbuf);
  210.                                                 normalize(&lbuf);
  211.                                                 for(i=0; i < lbuf; i++)
  212.                                                   {
  213.                                                     read(infile,&j,4);
  214.                                                     putit(j);
  215.                                                   }
  216.                                                 break;
  217.                                       }
  218.                                     read(infile,&lbuf,4);
  219.                                     putit(lbuf);
  220.                                     j = lbuf; 
  221.                                     normalize(&lbuf);
  222.                                   }
  223.                                 break;
  224.                 case 0x3F0:     /* hunk_symbol */
  225.                                 read(infile,&lbuf,4);
  226.                                 putit(lbuf);
  227.                                 j = lbuf;
  228.                                 normalize(&lbuf);
  229.                                 typ = (j >> 24) & 0xFF;
  230.                                 j &= 0xFFFFFF;
  231.                                 normalize(&j);
  232.                                 lbuf = j;
  233.                                 if (debug)
  234.                                   printf("  hunk_symbol, typ=%d, len=%d\n",typ,lbuf);
  235.                                 switch(typ)
  236.                                   {
  237.                                         case 0: /* ext_def */
  238.                                                 for(i=0; i < lbuf; i++)
  239.                                                   {
  240.                                                     read(infile,&j,4);
  241.                                                     putit(j);
  242.                                                   }
  243.                                                 read(infile,&j,4); /* value */
  244.                                                 putit(j);
  245.                                                 break;
  246.                                   }
  247.                                 break;
  248.  
  249.                 case 0x3F2:     /* hunk_end */
  250.                                 if (debug)
  251.                                   printf("nxtsym= %d\n",nxtsym);
  252.                                 if (nxtsym)
  253.                                   putit(0xF0030000);      /* 000003f0 in 8086 order */
  254.                                 for(i = 0; i < nxtsym; i++)
  255.                                   {
  256.                                         /* put out symtable records */
  257.                                         putit(symhunk[i].len);
  258.                                         normalize(&symhunk[i].len);
  259.                                         if (debug)
  260.                                           printf("extsym len = %d\n",symhunk[i].len);
  261.  
  262.                                         for(j=0; j < symhunk[i].len; j++)
  263.                                           putit(symhunk[i].sym[j]);
  264.                                         putit(symhunk[i].value);
  265.                                   } 
  266.                                 if (nxtsym)
  267.                                   putit(0L);
  268.                                 nxtsym = 0;
  269.                                 putit(0xF2030000);
  270.                                 break;
  271.         }                       
  272.     }
  273.   if (debug)
  274.     printf("EOF detected\n");
  275.   close(infile);
  276.   close(f);
  277.   CopyItBack(fname);
  278. }
  279.  
  280. putit(l)
  281. unsigned long l;
  282. {
  283.   write(f,&l,4);
  284. }
  285.  
  286. normalize(lp)
  287. long *lp;
  288. {
  289.  
  290.   unsigned char hilo[4];
  291.   unsigned char lohi[4];
  292.  
  293.   BlockMove(lp,hilo,4);
  294.   lohi[0] = hilo[3];
  295.   lohi[1] = hilo[2];
  296.   lohi[2] = hilo[1];
  297.   lohi[3] = hilo[0];
  298.   BlockMove(lohi,lp,4);
  299. }
  300.  
  301.  
  302. BlockMove(p,q,l)
  303. unsigned char *p,*q;
  304. int l;
  305. {
  306.   while(l--)
  307.     *q++ = *p++;
  308. }
  309.  
  310. CopyItBack(fname)
  311. char *fname;
  312. {
  313.   int infile;
  314.   int f;
  315.   char buf[1024];       /* 1k at a time */
  316.   long l;
  317.  
  318.   infile = open("cnv.tmp",0);
  319.  
  320. #ifdef MSC30
  321.   f = creat(fname,S_IREAD | S_IWRITE);       /* assume binary mode */
  322. #endif
  323.  
  324. #ifdef LATTI
  325.   f = creat(fname, O_RAW | O_RDWR );       /* assume binary mode */
  326. #endif
  327.  
  328.  
  329.   while(1)
  330.     {
  331.       l = read(infile,buf,sizeof(buf));
  332.       if (l)
  333.         write(f,buf,l);
  334.       if (l != sizeof(buf))
  335.         break;
  336.     }
  337.   close(infile);
  338.   close(f);
  339.   unlink("cnv.tmp");
  340. }
  341.